home *** CD-ROM | disk | FTP | other *** search
/ Aminet 41 / Aminet 41 (2001)(Schatztruhe)[!][Feb 2001].iso / Aminet / dev / c / GSys.lha / gsys / gsystem / GBuffer.cpp next >
Encoding:
C/C++ Source or Header  |  2000-10-16  |  3.8 KB  |  237 lines
  1.  
  2. /* Author Anders Kjeldsen */
  3.  
  4. #ifndef GBUFFER_CPP
  5. #define GBUFFER_CPP
  6.  
  7. #include "gsystem/GBuffer.h"
  8. #include "gsystem/GObject.cpp"
  9.  
  10. GBuffer::GBuffer(GSTRPTR filename, GUWORD start, GUWORD len)
  11. {
  12.     memset((void *)this, 0, sizeof (class GBuffer) );
  13. //    WriteLog("Init\n");
  14.     if ( InitGObject("GBuffer") )
  15.     {
  16. //        WriteLog("Inited\n");
  17.         Locked = TRUE;
  18.         Buffer = NULL;    // Load() checks if Buffer is non-zero!
  19. //        WriteLog("Load\n");
  20.         if ( Load(filename, start, len) )
  21.         {
  22.         }
  23.     }
  24. }
  25.  
  26. GBuffer::GBuffer(GUWORD size)
  27. {
  28.     memset((void *)this, 0, sizeof (class GBuffer) );
  29.     if ( InitGObject("GBuffer") )
  30.     {
  31.         Locked = TRUE;
  32.         Buffer = (GAPTR) new char[size];
  33.  
  34.         if (Buffer)
  35.         {
  36.             Size = size;
  37.             FilePtr = 0;
  38.         }
  39.     }
  40. }
  41.  
  42. GBuffer::~GBuffer()
  43. {
  44.     if (Buffer)
  45.     {
  46.         delete Buffer;
  47.     }
  48. }
  49.  
  50. BOOL GBuffer::InitGBuffer(GSTRPTR filename, GUWORD start, GUWORD len, GSTRPTR objtype)
  51. {
  52.     if (Buffer)
  53.     {
  54.         delete Buffer;
  55.     }
  56. //    WriteLog("memset\n");
  57.     memset((void *)this, 0, sizeof (class GBuffer) );
  58.     if ( InitGObject(objtype) )
  59.     {
  60.  
  61.         Locked = TRUE;
  62.         Buffer = NULL;
  63. //        WriteLog("Load\n");
  64.         if ( Load(filename, start, len ) )
  65.         {
  66.             return TRUE;
  67.         }
  68.         return FALSE;
  69.     }
  70.     return FALSE;
  71. }
  72.  
  73. BOOL GBuffer::InitGBuffer(GUWORD size, GSTRPTR objtype)
  74. {
  75.     if (Buffer)
  76.     {
  77.         delete Buffer;
  78.     }
  79.  
  80.     memset((void *)this, 0, sizeof (class GBuffer) );
  81.     if ( InitGObject(objtype) )
  82.     {
  83.         Locked = TRUE;
  84.         Buffer = (GAPTR) new char[size];
  85.  
  86.         if (Buffer)
  87.         {
  88.             Size = size;
  89.             FilePtr = 0;
  90.             return TRUE;
  91.         }
  92.         return FALSE;
  93.     }
  94.     return FALSE;
  95. }
  96.  
  97. GAPTR GBuffer::LockBuf() 
  98. { 
  99.     if (!Buffer)
  100.     {
  101. //        WriteLog("Loading of backed up memory is not available yet!\n");
  102.         return NULL;
  103.     }
  104.     else
  105.     {
  106.         Locked = TRUE; 
  107.         return Buffer;
  108.     }
  109. } 
  110.  
  111. /*
  112.  
  113. BOOL GBuffer::Load(GSTRPTR filename, GUWORD start, GUWORD len)
  114. {
  115.     if (Buffer)
  116.     {
  117.         delete Buffer;
  118.         Buffer = NULL;
  119.     }
  120.  
  121.     HANDLE fh;
  122.     DWORD SizeHigh;
  123.     SizeHigh = 0;
  124.  
  125.     if (filename)
  126.     {
  127.         if ( fh = CreateFile( filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, NULL, NULL) )
  128.         {
  129.             Size = GetFileSize(fh, &SizeHigh);
  130.             if (Size > start)
  131.             {
  132.                 if ( Size != -1)
  133.                 {
  134.                     FileSize = Size;
  135.                     if ( len != 0 )
  136.                     {
  137.                         GWORD delta = Size-(start+len);
  138.                         if (delta < 0)
  139.                         {
  140.                             len+= delta;
  141.                         }
  142.                         Size = len;
  143.                     }
  144.                     else
  145.                     {
  146.                         len = Size;
  147.                     }
  148.  
  149.                     Buffer = (GAPTR) new char[Size+16];
  150.                     if (Buffer)
  151.                     {
  152.                         if ( SetFilePointer(fh, start, NULL, FILE_BEGIN) != -1 )
  153.                         {
  154.                             FilePtr = start;
  155.                             strncpy(FileName, filename, 255);
  156.                             SizeHigh = 0;
  157.                             ReadFile(fh, Buffer, Size, &SizeHigh, 0);
  158.                             ((char *)Buffer)[Size] = 0;
  159.                             return TRUE;
  160.                         }
  161.                         else WriteLog("Load: SetFilePointer Failed\n");
  162.                     }
  163.                 }
  164.             }
  165.             CloseHandle(fh);
  166.         }
  167.     }
  168.     return FALSE;
  169. }
  170. */
  171. /*
  172. BOOL GBuffer::Seek(GWORD offset, GUWORD seekmode)
  173. {
  174.     if ( seekmode == GSEEK_START ) FilePtr = 0;
  175.     else if ( seekmode == GSEEK_END ) FilePtr = FileSize;
  176.  
  177.     if (*FileName && FileSize)
  178.     {
  179.         FilePtr += offset;
  180.         if (FilePtr && (FilePtr < FileSize) )
  181.         {
  182.             return TRUE;
  183.         }
  184.     }
  185.     return FALSE;
  186. }
  187.  
  188. // note: it updates the FilePtr !
  189. GUWORD GBuffer::Peek(GUWORD len)
  190. {
  191.     HANDLE fh;
  192.     DWORD SizeHigh;
  193.     SizeHigh = 0;
  194.     GWORD delta;
  195.     
  196.     if (*FileName && FileSize)
  197.     {
  198.         if ( fh = CreateFile( FileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, NULL, NULL) )
  199.         {
  200.             if (FileSize > FilePtr)
  201.             {
  202.                 delta = FileSize-(FilePtr+len);
  203.                 if (delta < 0)
  204.                 {
  205.                     len+= delta;
  206.                 }
  207.  
  208.                 if ( Size != len )
  209.                 {
  210.                     if (Buffer) delete Buffer;
  211.                     Buffer = (GAPTR) new char[len+16];
  212.                     ((char *)Buffer)[len] = 0;
  213.                 }
  214.                 Size = len;
  215.                 if (Buffer)
  216.                 {
  217.                     if ( SetFilePointer(fh, FilePtr, NULL, FILE_BEGIN) != -1 )
  218.                     {
  219.                         FilePtr += Size;
  220. //                        SizeHigh = 0;
  221.                         ReadFile(fh, Buffer, Size, &SizeHigh, 0);
  222.                         return Size;
  223.                     }
  224.                     else WriteLog("Load: SetFilePointer Failed\n");
  225.                 }
  226.             }
  227.             CloseHandle(fh);
  228.         }
  229.     }
  230.     return FALSE;
  231. }
  232.  
  233. */
  234.  
  235. #endif /* GBUFFER_CPP */
  236.  
  237.